In [2]:
#carregamento de todas as imagens
import cv2
import numpy as np
import matplotlib.pyplot as plt
def exibir_imagens_lado_a_lado(imagens, titulos, figsize=(20, 5), cmap=None):
# Criar subplots com o número de imagens fornecido
fig, axs = plt.subplots(1, len(imagens), figsize=figsize)
# Garantir que axs seja uma lista (caso haja apenas uma imagem)
if len(imagens) == 1:
axs = [axs]
# Exibir cada imagem no subplot correspondente
for ax, img, titulo in zip(axs, imagens, titulos):
# Exibir a imagem
ax.imshow(img, cmap=cmap)
# Configurar o título e desativar os eixos
ax.set_title(titulo)
ax.axis('off')
plt.tight_layout()
plt.show()
def carregar_imagens(caminho_base, quantidade, formato="RGB"):
imagens = []
for i in range(1, quantidade + 1):
caminho = f"{caminho_base}{i}.jpg"
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar imagem {caminho}")
continue
# Converter o formato de cor, se necessário
if formato.upper() == "RGB":
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
elif formato.upper() == "GRAY":
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagens.append(imagem)
return imagens
canetas = carregar_imagens("canetas/caneta", 10)
borrachas = carregar_imagens("borracha/borracha", 10)
livros = carregar_imagens("livros/livro", 10)
caneta_titulos = [f"Caneta{idx}" for idx in range(1, len(canetas) + 1)]
exibir_imagens_lado_a_lado(canetas, caneta_titulos)
borracha_titulos = [f"Borracha {idx}" for idx in range(1, len(borrachas) + 1)]
exibir_imagens_lado_a_lado(borrachas, borracha_titulos)
livro_titulos = [f"Livro {idx}" for idx in range(1, len(livros) + 1)]
exibir_imagens_lado_a_lado(livros, livro_titulos)
In [3]:
#data augmentation das canetas
# Diretórios para salvar as imagens
C_espelhamento = "canetas_espelhamento/"
C_zoom = "canetas_zoom/"
C_rotacao = "canetas_rotacao/"
# Função para aplicar espelhamento horizontal
def flip_image(image):
return cv2.flip(image, 1)
# Função para aplicar zoom
def zoom_image(image, zoom_factor=1.2):
height, width = image.shape[:2]
center_x, center_y = width // 2, height // 2
new_width, new_height = int(width / zoom_factor), int(height / zoom_factor)
start_x = center_x - new_width // 2
start_y = center_y - new_height // 2
cropped = image[start_y:start_y + new_height, start_x:start_x + new_width]
return cv2.resize(cropped, (width, height))
# Função para aplicar rotação
def rotate_image(image, angle):
height, width = image.shape[:2]
center = (width // 2, height // 2)
rotation_matrix = cv2.getRotationMatrix2D(center, angle, 1.0)
return cv2.warpAffine(image, rotation_matrix, (width, height),borderValue=(255, 255, 255))
# Listas para armazenar imagens transformadas
canetasEspelhamento = []
canetasZoom = []
canetasRotacao = []
# Carregar e processar imagens
for i in range(len(canetas)):
# Aplicar espelhamento
imagem_flip = flip_image(canetas[i])
canetasEspelhamento.append(imagem_flip)
caminho_flip = f"{C_espelhamento}caneta_espelhamento{i+1}.jpg"
cv2.imwrite(caminho_flip, cv2.cvtColor(imagem_flip, cv2.COLOR_RGB2BGR))
# Aplicar zoom
imagem_zoom = zoom_image(canetas[i])
canetasZoom.append(imagem_zoom)
caminho_zoom = f"{C_zoom}caneta_zoom{i+1}.jpg"
cv2.imwrite(caminho_zoom, cv2.cvtColor(imagem_zoom, cv2.COLOR_RGB2BGR))
# Aplicar rotação
imagem_rotacao = rotate_image(canetas[i], angle=15) # Exemplo: rotação de 15 graus
canetasRotacao.append(imagem_rotacao)
caminho_rotacao = f"{C_rotacao}caneta_rotacao{i+1}.jpg"
cv2.imwrite(caminho_rotacao, cv2.cvtColor(imagem_rotacao, cv2.COLOR_RGB2BGR))
canetas_espelhamento = [f"{idx} espelhamento" for idx in range(1, len(canetasEspelhamento) + 1)]
exibir_imagens_lado_a_lado(canetasEspelhamento, canetas_espelhamento)
canetas_zoom = [f"{idx} zoom" for idx in range(1, len(canetasZoom) + 1)]
exibir_imagens_lado_a_lado(canetasZoom, canetas_zoom)
canetas_rotacao = [f"{idx} rotação" for idx in range(1, len(canetasRotacao) + 1)]
exibir_imagens_lado_a_lado(canetasRotacao, canetas_rotacao )
In [4]:
#data augmentation das borrachas
# Diretórios para salvar as imagens
B_espelhamento = "borrachas_espelhamento/"
B_zoom = "borrachas_zoom/"
B_rotacao = "borrachas_rotacao/"
# Listas para armazenar imagens transformadas
borrachasEspelhamento = []
borrachasZoom = []
borrachasRotacao = []
# Carregar e processar imagens
for i in range(len(borrachas)):
# Aplicar espelhamento
imagem_flip = flip_image(borrachas[i])
borrachasEspelhamento.append(imagem_flip)
caminho_flip = f"{B_espelhamento}borracha_espelhamento{i+1}.jpg"
cv2.imwrite(caminho_flip, cv2.cvtColor(imagem_flip, cv2.COLOR_RGB2BGR))
# Aplicar zoom
imagem_zoom = zoom_image(borrachas[i])
borrachasZoom.append(imagem_zoom)
caminho_zoom = f"{B_zoom}borracha_zoom{i+1}.jpg"
cv2.imwrite(caminho_zoom, cv2.cvtColor(imagem_zoom, cv2.COLOR_RGB2BGR))
# Aplicar rotação
imagem_rotacao = rotate_image(borrachas[i], angle=15) # Exemplo: rotação de 15 graus
borrachasRotacao.append(imagem_rotacao)
caminho_rotacao = f"{B_rotacao}borracha_rotacao{i+1}.jpg"
cv2.imwrite(caminho_rotacao, cv2.cvtColor(imagem_rotacao, cv2.COLOR_RGB2BGR))
borrachas_espelhamento = [f"{idx} espelhamento" for idx in range(1, len(borrachasEspelhamento) + 1)]
exibir_imagens_lado_a_lado(borrachasEspelhamento, borrachas_espelhamento)
borrachas_zoom = [f"{idx} zoom" for idx in range(1, len(borrachasZoom) + 1)]
exibir_imagens_lado_a_lado(borrachasZoom, borrachas_zoom)
borrachas_rotacao = [f"{idx} rotação" for idx in range(1, len(borrachasRotacao) + 1)]
exibir_imagens_lado_a_lado(borrachasRotacao, borrachas_rotacao )
In [5]:
#data augmentation dos livros
# Diretórios para salvar as imagens
L_espelhamento = "livros_espelhamento/"
L_zoom = "livros_zoom/"
L_rotacao = "livros_rotacao/"
# Listas para armazenar imagens transformadas
livrosEspelhamento = []
livrosZoom = []
livrosRotacao = []
# Carregar e processar imagens
for i in range(len(livros)):
# Aplicar espelhamento
imagem_flip = flip_image(livros[i])
livrosEspelhamento.append(imagem_flip)
caminho_flip = f"{L_espelhamento}livro_espelhamento{i+1}.jpg"
cv2.imwrite(caminho_flip, cv2.cvtColor(imagem_flip, cv2.COLOR_RGB2BGR))
# Aplicar zoom
imagem_zoom = zoom_image(livros[i])
livrosZoom.append(imagem_zoom)
caminho_zoom = f"{L_zoom}livro_zoom{i+1}.jpg"
cv2.imwrite(caminho_zoom, cv2.cvtColor(imagem_zoom, cv2.COLOR_RGB2BGR))
# Aplicar rotação
imagem_rotacao = rotate_image(livros[i], angle=15) # Exemplo: rotação de 15 graus
livrosRotacao.append(imagem_rotacao)
caminho_rotacao = f"{L_rotacao}livro_rotacao{i+1}.jpg"
cv2.imwrite(caminho_rotacao, cv2.cvtColor(imagem_rotacao, cv2.COLOR_RGB2BGR))
livros_espelhamento = [f"{idx} espelhamento" for idx in range(1, len(livrosEspelhamento) + 1)]
exibir_imagens_lado_a_lado(livrosEspelhamento, livros_espelhamento)
livros_zoom = [f"{idx} zoom" for idx in range(1, len(livrosZoom) + 1)]
exibir_imagens_lado_a_lado(livrosZoom, livros_zoom)
livros_rotacao = [f"{idx} rotação" for idx in range(1, len(livrosRotacao) + 1)]
exibir_imagens_lado_a_lado(livrosRotacao, livros_rotacao )
In [4]:
# Função para aplicar zoom inverso
def zoom_out(image, scale=1.5):
height, width = image.shape[:2]
new_height, new_width = int(height * scale), int(width * scale)
# Determinar se a imagem é colorida ou em escala de cinza
if len(image.shape) == 2: # Escala de cinza
result = np.full((new_height, new_width), 255, dtype=np.uint8) # Quadro branco em escala de cinza
else: # Colorida
result = np.full((new_height, new_width, 3), 255, dtype=np.uint8) # Quadro branco colorido
start_y = (new_height - height) // 2
start_x = (new_width - width) // 2
result[start_y:start_y + height, start_x:start_x + width] = image
return result
# Função para aplicar zoom padrão
def zoom_in(image, zoom_factor=1.2):
height, width = image.shape[:2]
center_x, center_y = width // 2, height // 2
new_width, new_height = int(width / zoom_factor), int(height / zoom_factor)
start_x = center_x - new_width // 2
start_y = center_y - new_height // 2
cropped = image[start_y:start_y + new_height, start_x:start_x + new_width]
return cv2.resize(cropped, (width, height))
In [3]:
#segmentação das imagens originais
livrosSegmentados = []
canetasSegmentadas = []
borrachasSegmentadas = []
# Diretórios para salvar as imagens
C_original = "imagens_limiarizadas/canetas/original/"
B_original = "imagens_limiarizadas/borrachas/original/"
L_original = "imagens_limiarizadas/livros/original/"
#limiarização da imagens dos livros
for i in range(1, 11):
caminho = f'livros/livro{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f'erro ao carregar imagem {caminho}')
continue
# Convertendo para escala de cinza
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
# Aplicando filtro Gaussiano
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
imagem_blur = zoom_out(imagem_blur)
# Aplicando limiarização
_, thresh = cv2.threshold(imagem_blur, 120, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((25, 25), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=30)
thresh = cv2.erode(dilatacao, kernel, iterations=40)
thresh = cv2.dilate(thresh, kernel, iterations=10)
thresh = zoom_in(thresh, zoom_factor=1.5)
caminho_livro = f"{L_original}livro_original{i}.jpg"
cv2.imwrite(caminho_livro, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
livrosSegmentados.append(thresh) # Armazenar a imagem processada
#limiarização da imagens das borrachas
for i in range(1, 11):
caminho = f'borracha/borracha{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f'erro ao carregar imagem {caminho}')
continue
# Convertendo para escala de cinza
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
# Aplicando filtro Gaussiano
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
# Aplicando limiarização
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((15, 15), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=5)
thresh = cv2.erode(dilatacao, kernel, iterations=6)
caminho_borracha = f"{B_original}borracha_original{i}.jpg"
cv2.imwrite(caminho_borracha, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
borrachasSegmentadas.append(thresh) # Armazenar a imagem processada
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'canetas/caneta{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((15, 15), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=5)
thresh = cv2.erode(dilatacao, kernel, iterations=6)
caminho_caneta = f"{C_original}caneta_original{i}.jpg"
cv2.imwrite(caminho_caneta, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
canetasSegmentadas.append(thresh)
caneta_segmentada = [f"limiarizada{idx}" for idx in range(1, len(canetasSegmentadas) + 1)]
exibir_imagens_lado_a_lado(canetasSegmentadas, caneta_segmentada, cmap='gray')
borracha_segmentada = [f"limiarizada{idx}" for idx in range(1, len(borrachasSegmentadas) + 1)]
exibir_imagens_lado_a_lado(borrachasSegmentadas, borracha_segmentada, cmap='gray')
livro_segmentada = [f"limiarizada{idx}" for idx in range(1, len(livrosSegmentados) + 1)]
exibir_imagens_lado_a_lado(livrosSegmentados, livro_segmentada, cmap='gray')
In [4]:
#segmentação das canetas em data augmentation
canetasEsp = carregar_imagens("canetas_espelhamento/caneta_espelhamento", 10)
canetasZooms = carregar_imagens("canetas_zoom/caneta_zoom", 10)
canetasRota = carregar_imagens("canetas_rotacao/caneta_rotacao", 10)
# Diretórios para salvar as imagens
C_espelhada = "imagens_limiarizadas/canetas/espelhada/"
C_zoom = "imagens_limiarizadas/canetas/zoom/"
C_rotacao = "imagens_limiarizadas/canetas/rotacao/"
canetasSegEspelhamento = []
canetasSegZoom = []
canetasSegRotacao = []
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'canetas_espelhamento/caneta_espelhamento{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((15, 15), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=5)
thresh = cv2.erode(dilatacao, kernel, iterations=6)
caneta_espelhada = f"{C_espelhada}caneta_espelhada{i}.jpg"
cv2.imwrite(caneta_espelhada, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
canetasSegEspelhamento.append(thresh)
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'canetas_zoom/caneta_zoom{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((15, 15), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=5)
caneta_zoom = f"{C_zoom}caneta_zoom{i}.jpg"
cv2.imwrite(caneta_zoom, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
thresh = cv2.erode(dilatacao, kernel, iterations=6)
canetasSegZoom.append(thresh)
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'canetas_rotacao/caneta_rotacao{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((15, 15), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=5)
thresh = cv2.erode(dilatacao, kernel, iterations=6)
caneta_rotacao = f"{C_rotacao}caneta_rotacao{i}.jpg"
cv2.imwrite(caneta_rotacao, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
canetasSegRotacao.append(thresh)
caneta_segEsp = [f"espelhamento {idx}" for idx in range(1, len(canetasSegEspelhamento) + 1)]
exibir_imagens_lado_a_lado(canetasSegEspelhamento, caneta_segEsp, cmap='gray')
caneta_segZoom = [f"zoom {idx}" for idx in range(1, len(canetasSegZoom) + 1)]
exibir_imagens_lado_a_lado(canetasSegZoom, caneta_segZoom, cmap='gray')
caneta_segRota = [f"rotação {idx}" for idx in range(1, len(canetasSegRotacao) + 1)]
exibir_imagens_lado_a_lado(canetasSegRotacao, caneta_segRota, cmap='gray')
In [5]:
#segmentação das borrachas em data augmentation
borrachasEsp = carregar_imagens("borrachas_espelhamento/borracha_espelhamento", 10)
borrachasZooms = carregar_imagens("borrachas_zoom/borracha_zoom", 10)
borrachasRota = carregar_imagens("borrachas_rotacao/borracha_rotacao", 10)
# Diretórios para salvar as imagens
B_espelhada = "imagens_limiarizadas/borrachas/espelhada/"
B_zoom = "imagens_limiarizadas/borrachas/zoom/"
B_rotacao = "imagens_limiarizadas/borrachas/rotacao/"
borrachasSegEspelhamento = []
borrachasSegZoom = []
borrachasSegRotacao = []
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'borrachas_espelhamento/borracha_espelhamento{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((15, 15), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=5)
thresh = cv2.erode(dilatacao, kernel, iterations=6)
borracha_espelhada = f"{B_espelhada}borracha_espelhada{i}.jpg"
cv2.imwrite(borracha_espelhada, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
borrachasSegEspelhamento.append(thresh)
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'borrachas_zoom/borracha_zoom{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((15, 15), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=5)
thresh = cv2.erode(dilatacao, kernel, iterations=6)
borracha_zoom = f"{B_zoom}borracha_zoom{i}.jpg"
cv2.imwrite(borracha_zoom, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
borrachasSegZoom.append(thresh)
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'borrachas_rotacao/borracha_rotacao{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((15, 15), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=5)
thresh = cv2.erode(dilatacao, kernel, iterations=6)
borracha_rotacao = f"{B_rotacao}borracha_rotacao{i}.jpg"
cv2.imwrite(borracha_rotacao, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
borrachasSegRotacao.append(thresh)
borracha_segEsp = [f"espelhamento {idx}" for idx in range(1, len(borrachasSegEspelhamento) + 1)]
exibir_imagens_lado_a_lado(borrachasSegEspelhamento, borracha_segEsp, cmap='gray')
borracha_segZoom = [f"zoom {idx}" for idx in range(1, len(borrachasSegZoom) + 1)]
exibir_imagens_lado_a_lado(borrachasSegZoom, borracha_segZoom, cmap='gray')
borracha_segRota = [f"rotação {idx}" for idx in range(1, len(borrachasSegRotacao) + 1)]
exibir_imagens_lado_a_lado(borrachasSegRotacao, borracha_segRota, cmap='gray')
In [6]:
#segmentação dos livros em data augmentation
livrosEsp = carregar_imagens("livros_espelhamento/livro_espelhamento", 10)
livrosZooms = carregar_imagens("livros_zoom/livro_zoom", 10)
livrosRota = carregar_imagens("livros_rotacao/livro_rotacao", 10)
# Diretórios para salvar as imagens
L_espelhada = "imagens_limiarizadas/livros/espelhada/"
L_zoom = "imagens_limiarizadas/livros/zoom/"
L_rotacao = "imagens_limiarizadas/livros/rotacao/"
livrosSegEspelhamento = []
livrosSegZoom = []
livrosSegRotacao = []
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'livros_espelhamento/livro_espelhamento{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
imagem_blur = zoom_out(imagem_blur)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((25, 25), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=30)
thresh = cv2.erode(dilatacao, kernel, iterations=40)
thresh = cv2.dilate(thresh, kernel, iterations=10)
thresh = zoom_in(thresh, zoom_factor=1.5)
livro_espelhada = f"{L_espelhada}livro_espelhada{i}.jpg"
cv2.imwrite(livro_espelhada, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
livrosSegEspelhamento.append(thresh)
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'livros_zoom/livro_zoom{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
imagem_blur = zoom_out(imagem_blur)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((25, 25), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=30)
thresh = cv2.erode(dilatacao, kernel, iterations=40)
thresh = cv2.dilate(thresh, kernel, iterations=10)
thresh = zoom_in(thresh, zoom_factor=1.5)
livro_zoom = f"{L_zoom}livro_zoom{i}.jpg"
cv2.imwrite(livro_zoom, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
livrosSegZoom.append(thresh)
#limiarização da imagens das canetas
for i in range(1, 11): # De 1 a 10
caminho = f'livros_rotacao/livro_rotacao{i}.jpg'
imagem = cv2.imread(caminho)
if imagem is None:
print(f"Erro ao carregar a imagem {caminho}")
continue
imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
imagem_blur = zoom_out(imagem_blur)
_, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
kernel = np.ones((25, 25), np.uint8)
dilatacao = cv2.dilate(thresh, kernel, iterations=30)
thresh = cv2.erode(dilatacao, kernel, iterations=40)
thresh = cv2.dilate(thresh, kernel, iterations=10)
thresh = zoom_in(thresh, zoom_factor=1.5)
livro_rotacao = f"{L_rotacao}livro_rotacao{i}.jpg"
cv2.imwrite(livro_rotacao, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
livrosSegRotacao.append(thresh)
livro_segEsp = [f"espelhamento {idx}" for idx in range(1, len(livrosSegEspelhamento) + 1)]
exibir_imagens_lado_a_lado(livrosSegEspelhamento, livro_segEsp, cmap='gray')
livro_segZoom = [f"zoom {idx}" for idx in range(1, len(livrosSegZoom) + 1)]
exibir_imagens_lado_a_lado(livrosSegZoom, livro_segZoom, cmap='gray')
livro_segRota = [f"rotação {idx}" for idx in range(1, len(livrosSegRotacao) + 1)]
exibir_imagens_lado_a_lado(livrosSegRotacao, livro_segRota, cmap='gray')
In [1]:
import cv2
import numpy as np
from matplotlib import pyplot as plt
# Load the image
image_path = 'imagem_com_fronteira_livrosSegZoom922.jpg'
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
# Binarize the image
_, imagem_bin = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)
def seguidor_de_fronteira(imagem):
contornos, _ = cv2.findContours(imagem, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
if not contornos:
return imagem
maior_contorno = max(contornos, key=cv2.contourArea)
return maior_contorno
def destacar_fronteira(imagem, contorno):
imagem_com_fronteira = imagem.copy()
cv2.drawContours(imagem_com_fronteira, [contorno], -1, (255,0,0), 20) # BGR (vermelho)
return imagem_com_fronteira
contorno = seguidor_de_fronteira(imagem_bin)
imagem_colorida = cv2.cvtColor(imagem_bin, cv2.COLOR_GRAY2BGR)
imagem_com_fronteira = destacar_fronteira(imagem_colorida, contorno)
plt.imshow(imagem_com_fronteira)
plt.title('Imagem com Fronteira em Vermelho')
plt.show()
In [2]:
import math
def resample(contorno, num_pontos):
perimetro = 0
for i in range(len(contorno)):
if i == len(contorno) - 1:
dx = contorno[0][0][0] - contorno[i][0][0]
dy = contorno[0][0][1] - contorno[i][0][1]
else:
dx = contorno[i+1][0][0] - contorno[i][0][0]
dy = contorno[i+1][0][1] - contorno[i][0][1]
perimetro += math.sqrt(dx**2 + dy**2)
intervalo = perimetro / num_pontos
pontos_reamostrados = []
distancia_acumulada = 0
i = 0
for j in range(num_pontos):
distancia_alvo = intervalo * j
while distancia_acumulada < distancia_alvo:
if i == len(contorno) - 1:
dx = contorno[0][0][0] - contorno[i][0][0]
dy = contorno[0][0][1] - contorno[i][0][1]
else:
dx = contorno[i+1][0][0] - contorno[i][0][0]
dy = contorno[i+1][0][1] - contorno[i][0][1]
segmento_comprimento = math.sqrt(dx**2+dy**2)
if distancia_acumulada + segmento_comprimento < distancia_alvo:
distancia_acumulada += segmento_comprimento
i = (i+1)%len(contorno)
else:
#Interpolação linear
t = (distancia_alvo - distancia_acumulada) / segmento_comprimento
x = contorno[i][0][0] + t * dx
y = contorno[i][0][1] + t * dy
pontos_reamostrados.append([int(x),int(y)])
break
return np.array(pontos_reamostrados).reshape(-1, 1, 2)
contorno_reamostrado = resample(contorno, 30) # Exemplo: 16 pontos
imagem_reamostrada = destacar_fronteira(imagem_colorida.copy(), contorno_reamostrado)
plt.imshow(imagem_reamostrada)
plt.title('Imagem com Contorno Reamostrado')
plt.show()
In [3]:
def gerar_codigo_cadeia(contorno):
code = []
for i in range(len(contorno)):
if i == len(contorno)-1:
dx = contorno[0][0][0] - contorno[i][0][0]
dy = contorno[0][0][1] - contorno[i][0][1]
else:
dx = contorno[i+1][0][0] - contorno[i][0][0]
dy = contorno[i+1][0][1] - contorno[i][0][1]
if dx == 0 and dy < 0:
code.append(0)
elif dx > 0 and dy < 0:
code.append(1)
elif dx > 0 and dy == 0:
code.append(2)
elif dx > 0 and dy > 0:
code.append(3)
elif dx == 0 and dy > 0:
code.append(4)
elif dx < 0 and dy > 0:
code.append(5)
elif dx < 0 and dy == 0:
code.append(6)
elif dx < 0 and dy < 0:
code.append(7)
return code
codigo_cadeia = gerar_codigo_cadeia(contorno_reamostrado)
print("Código de cadeia:", codigo_cadeia)
Código de cadeia: [6, 6, 7, 5, 3, 3, 3, 3, 4, 4, 5, 5, 3, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 5]
In [4]:
def normalizar_codigo_cadeia(codigo_cadeia):
min_codigo = codigo_cadeia[:]
min_valor = int("".join(map(str, codigo_cadeia))) # Converte a lista para string e em seguida para int
for i in range(len(codigo_cadeia)):
codigo_rotacionado = codigo_cadeia[i:] + codigo_cadeia[:i]
valor_atual = int("".join(map(str, codigo_rotacionado)))
if valor_atual < min_valor:
min_valor = valor_atual
min_codigo = codigo_rotacionado
return min_codigo
codigo_cadeia_normalizado = normalizar_codigo_cadeia(codigo_cadeia)
print("Código de cadeia normalizado:", codigo_cadeia_normalizado)
Código de cadeia normalizado: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 5, 6, 6, 7, 5, 3, 3, 3, 3, 4, 4, 5, 5, 3, 1, 1, 1, 2]
In [6]:
def processar_imagem(imagem, num_pontos):
contorno = seguidor_de_fronteira(imagem)
contorno_reamostrado = resample(contorno, num_pontos)
codigo_cadeia = gerar_codigo_cadeia(contorno_reamostrado)
codigo_cadeia_normalizado = normalizar_codigo_cadeia(codigo_cadeia)
return codigo_cadeia_normalizado
num_pontos_finais = 30 #Quantidade de pontos finais desejados
codigo_normalizado = processar_imagem(imagem_bin, num_pontos_finais)
print("Código de cadeia normalizado:", codigo_normalizado)
Código de cadeia normalizado: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 5, 6, 6, 7, 5, 3, 3, 3, 3, 4, 4, 5, 5, 3, 1, 1, 1, 2]
In [7]:
import pandas as pd
import random
# ... (código anterior permanece inalterado)
"imagens_limiarizadas/livros/espelhada/"
resultados = []
num_imagens = 10
num_pontos_finais = 30
for i in range(num_imagens):
caneta_original = cv2.imread(f"imagens_limiarizadas/canetas/original/caneta_original{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
caneta_espelhada = cv2.imread(f"imagens_limiarizadas/canetas/espelhada/caneta_espelhada{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
caneta_zoom = cv2.imread(f"imagens_limiarizadas/canetas/zoom/caneta_zoom{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
caneta_rotacao = cv2.imread(f"imagens_limiarizadas/canetas/rotacao/caneta_rotacao{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
codigo_caneta_original = processar_imagem(caneta_original, num_pontos_finais)
resultados.append({'tipo': 'caneta', 'codigo': codigo_caneta_original, 'imagem': caneta_original})
codigo_caneta_espelhada = processar_imagem(caneta_espelhada, num_pontos_finais)
resultados.append({'tipo': 'caneta', 'codigo': codigo_caneta_espelhada, 'imagem': caneta_espelhada})
codigo_caneta_zoom = processar_imagem(caneta_zoom, num_pontos_finais)
resultados.append({'tipo': 'caneta', 'codigo': codigo_caneta_zoom, 'imagem': caneta_zoom})
codigo_caneta_rotacao = processar_imagem(caneta_rotacao, num_pontos_finais)
resultados.append({'tipo': 'caneta', 'codigo': codigo_caneta_rotacao, 'imagem': caneta_rotacao})
for i in range(num_imagens):
borracha_original = cv2.imread(f"imagens_limiarizadas/borrachas/original/borracha_original{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
borracha_espelhada = cv2.imread(f"imagens_limiarizadas/borrachas/espelhada/borracha_espelhada{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
borracha_zoom = cv2.imread(f"imagens_limiarizadas/borrachas/zoom/borracha_zoom{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
borracha_rotacao = cv2.imread(f"imagens_limiarizadas/borrachas/rotacao/borracha_rotacao{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
codigo_borracha_original = processar_imagem(borracha_original, num_pontos_finais)
resultados.append({'tipo': 'borracha', 'codigo': codigo_borracha_original, 'imagem': borracha_original})
codigo_borracha_espelhada = processar_imagem(borracha_espelhada, num_pontos_finais)
resultados.append({'tipo': 'borracha', 'codigo': codigo_borracha_espelhada, 'imagem': borracha_espelhada})
codigo_borracha_zoom = processar_imagem(borracha_zoom, num_pontos_finais)
resultados.append({'tipo': 'borracha', 'codigo': codigo_borracha_zoom, 'imagem': borracha_zoom})
codigo_borracha_rotacao = processar_imagem(borracha_rotacao, num_pontos_finais)
resultados.append({'tipo': 'borracha', 'codigo': codigo_borracha_rotacao, 'imagem': borracha_rotacao})
for i in range(num_imagens):
livro_original = cv2.imread(f"imagens_limiarizadas/livros/original/livro_original{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
livro_espelhada = cv2.imread(f"imagens_limiarizadas/livros/espelhada/livro_espelhada{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
livro_zoom = cv2.imread(f"imagens_limiarizadas/livros/zoom/livro_zoom{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
livro_rotacao = cv2.imread(f"imagens_limiarizadas/livros/rotacao/livro_rotacao{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
codigo_livro_original = processar_imagem(livro_original, num_pontos_finais)
resultados.append({'tipo': 'livro', 'codigo': codigo_livro_original, 'imagem': livro_original})
codigo_livro_espelhada = processar_imagem(livro_espelhada, num_pontos_finais)
resultados.append({'tipo': 'livro', 'codigo': codigo_livro_espelhada, 'imagem': livro_espelhada})
codigo_livro_zoom = processar_imagem(livro_zoom, num_pontos_finais)
resultados.append({'tipo': 'livro', 'codigo': codigo_livro_zoom, 'imagem': livro_zoom})
codigo_livro_rotacao = processar_imagem(livro_rotacao, num_pontos_finais)
resultados.append({'tipo': 'livro', 'codigo': codigo_livro_rotacao, 'imagem': livro_rotacao})
df_resultados = pd.DataFrame(resultados)
In [8]:
df_resultados = df_resultados.drop(columns=['imagem'])
for i in range(len(df_resultados['codigo'][0])):
df_resultados[f'codigo_{i}'] = df_resultados['codigo'].apply(lambda x: x[i])
df_resultados = df_resultados.drop(columns=['codigo'])
df_resultados
Out[8]:
| tipo | codigo_0 | codigo_1 | codigo_2 | codigo_3 | codigo_4 | codigo_5 | codigo_6 | codigo_7 | codigo_8 | ... | codigo_19 | codigo_20 | codigo_21 | codigo_22 | codigo_23 | codigo_24 | codigo_25 | codigo_26 | codigo_27 | codigo_28 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | caneta | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 7 | 7 | ... | 5 | 3 | 5 | 5 | 5 | 5 | 3 | 1 | 1 | 7 |
| 1 | caneta | 1 | 7 | 7 | 7 | 7 | 5 | 5 | 5 | 5 | ... | 3 | 1 | 7 | 7 | 7 | 7 | 7 | 7 | 7 | 7 |
| 2 | caneta | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | ... | 5 | 5 | 4 | 4 | 5 | 5 | 5 | 5 | 5 | 3 |
| 3 | caneta | 1 | 7 | 7 | 7 | 7 | 7 | 7 | 7 | 7 | ... | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 |
| 4 | caneta | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | ... | 5 | 5 | 5 | 5 | 5 | 5 | 5 | 3 | 1 | 7 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| 115 | livro | 1 | 1 | 1 | 1 | 1 | 1 | 7 | 7 | 7 | ... | 5 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 |
| 116 | livro | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 7 | 7 | ... | 3 | 3 | 1 | 1 | 2 | 1 | 1 | 1 | 1 | 1 |
| 117 | livro | 0 | 1 | 1 | 1 | 1 | 7 | 7 | 5 | 6 | ... | 3 | 3 | 3 | 2 | 3 | 3 | 3 | 1 | 7 | 7 |
| 118 | livro | 0 | 1 | 1 | 1 | 1 | 7 | 5 | 6 | 7 | ... | 3 | 1 | 1 | 2 | 1 | 1 | 1 | 1 | 1 | 1 |
| 119 | livro | 1 | 1 | 1 | 1 | 1 | 1 | 7 | 7 | 7 | ... | 5 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 |
120 rows × 30 columns
In [ ]: